package cn.learn.activiti.util;

import de.odysseus.el.ExpressionFactoryImpl;
import de.odysseus.el.util.SimpleContext;
import org.apache.commons.lang3.StringUtils;

import javax.el.ExpressionFactory;
import javax.el.ValueExpression;
import java.util.Map;

/**
 * JUEL表达式的工具类
 *
 * @author huangyezhan
 * @version 1.0
 * @date 2021年03月13日18:00
 */
public class JuelUtil {
    private JuelUtil() {
    }

    /**
     * 解析 uel 表达式
     *
     * @param el  表达式
     * @param map 设置进表达式的值，key为el表达式的占位符名称，value为值
     * @return 返回解析表达式后的结果
     */
    public static Object parseEl(String el, Map<String, Object> map) {
        //创建基本的工厂类和上下方以供下面使用
        ExpressionFactory factory = new ExpressionFactoryImpl();
        SimpleContext     context = new SimpleContext();
        //设置变量值
        for (String key : map.keySet()) {
            context.setVariable(key, factory.createValueExpression(map.get(key), map.get(key).getClass()));
        }
        //解析
        ValueExpression e = factory.createValueExpression(context, el, String.class);
        return e.getValue(context);
    }

    /**
     * 解析 uel 表达式
     *
     * @param el    表达式
     * @param name  表单时占位符的名称
     * @param value 需要替换的值
     * @return 返回解析表达式后的结果
     */
    public static Object parseEl(String el, String name, Object value) {
        //创建基本的工厂类和上下方以供下面使用
        ExpressionFactory factory = new ExpressionFactoryImpl();
        SimpleContext     context = new SimpleContext();
        //设置变量值
        context.setVariable(name, factory.createValueExpression(value, value.getClass()));
        //解析
        ValueExpression e = factory.createValueExpression(context, el, String.class);
        return e.getValue(context);
    }


    public static String string2El(String var) {
        String symbol = symbol(var);
        if (StringUtils.isEmpty(symbol)) {
            return null;
        }
        return "${" + symbol + "}";
    }


    private final static String eq1 = "=";

    /**
     * 主要是为了更换 = 为 ==
     * =为赋值符号 == 才是判断符号
     *
     * @param var 符号
     * @return 返回结果
     */
    private static String symbol(String var) {
        if (StringUtils.isEmpty(var)) {
            return null;
        }
        //先把特殊符号替换成  名称
        // !=
        if (var.contains(SymbolEnum.ne.getSym())) {
            var = var.replace(SymbolEnum.ne.getSym(), SymbolEnum.ne.getName());
        }
        // >=
        if (var.contains(SymbolEnum.ge.getSym())) {
            var = var.replace(SymbolEnum.ge.getSym(), SymbolEnum.ge.getName());
        }
        // <=
        if (var.contains(SymbolEnum.le.getSym())) {
            var = var.replace(SymbolEnum.le.getSym(), SymbolEnum.le.getName());
        }
        // ==
        if (var.contains(SymbolEnum.eq.getSym())) {
            var = var.replace(SymbolEnum.eq.getSym(), SymbolEnum.eq.getName());
        }

        // 把 = 替换成 ==
        if (var.contains(eq1)) {
            var = var.replace(eq1, SymbolEnum.eq.getSym());
        }

        // 全部替换回来
        // !=
        if (var.contains(SymbolEnum.ne.getName())) {
            var = var.replace(SymbolEnum.ne.getName(), SymbolEnum.ne.getSym());
        }
        // >=
        if (var.contains(SymbolEnum.ge.getName())) {
            var = var.replace(SymbolEnum.ge.getName(), SymbolEnum.ge.getSym());
        }
        // <=
        if (var.contains(SymbolEnum.le.getName())) {
            var = var.replace(SymbolEnum.le.getName(), SymbolEnum.le.getSym());
        }
        // ==
        if (var.contains(SymbolEnum.eq.getName())) {
            var = var.replace(SymbolEnum.eq.getName(), SymbolEnum.eq.getSym());
        }
        return var;
    }


}
